home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / asmutil / a86v400.zip / A14.DOC < prev    next >
Text File  |  1994-12-21  |  33KB  |  735 lines
  1. CHAPTER 14   DESCRIPTIONS OF A86 ERROR MESSAGES
  2.  
  3.  
  4. A86 signals successful assembly by returning an ERRORLEVEL of 0.
  5. If errors are detected during assembly, A86 returns an ERRORLEVEL
  6. of 1.  If undefined symbols remain at the end of assembly, A86
  7. returns an ERRORLEVEL of 2.
  8.  
  9. ERROR 01: Unknown Mnemonic
  10.  
  11.    Most assembly-language lines start with a built-in instruction
  12.    mnemonic such as MOV or ADD.  The only circumstances in which
  13.    a line can start with a non-built-in symbol are if the symbol
  14.    is a macro name or INT equate, or if the symbol is now being
  15.    defined, as indicated by a limited set of following symbols: a
  16.    colon, EQU, DB, DW, etc.  This line started with a
  17.    non-built-in symbol which did not fall into any of the above
  18.    categories.  You might have misspelled an instruction
  19.    mnemonic, or misspelled the following word.
  20.  
  21. ERROR 02: Jump > 128
  22.  
  23.    The destination operand of a conditional jump must be a label
  24.    within 128 bytes of the end of the instruction.  (Precisely,
  25.    from -128 to +127 from the next instruction, which is from
  26.    -126 to +129 from the start of the conditional jump.)  This
  27.    error can also occur from an unconditional JMP to a
  28.    forward-referenced local label, since A86 assumes the short
  29.    JMP form in that case.  This error is reported in three
  30.    possible places:
  31.  
  32.     1. At the jump.  The operand is more than 126 bytes before
  33.        the jump, or the operand is not a label (e.g. you tried an
  34.        indirect conditional jump through a variable, which isn't
  35.        allowed)
  36.  
  37.     2. At a label definition.  In this case, you use your editor
  38.        to search backwards for references to the label.  One or
  39.        more of the earliest conditional jumps found are too far
  40.        away.
  41.  
  42.     3. At a RET, RETF, or IRET instruction.  You use your editor
  43.        to search backwards for that flavor of RET used as the
  44.        operand to a conditional jump (the A86 conditional return
  45.        feature). The earliest such jumps not satisfied by a
  46.        previous RET are too far away.
  47.  
  48.    You usually correct this error by rearranging your code, or
  49.    (better) by breaking intervening code off into subroutines. If
  50.    desperate, you can replace "Jcond" with "IF cond JMP".
  51.  
  52. ERROR 03: [BX+BP] And [SI+DI] Not Allowed
  53.  
  54.    The 86 instruction set does not support the combinations of
  55.    indexing registers indicated in the error message.  In
  56.    previous versions of A86, this error was reported in other
  57.    illegal operand combinations; I've attempted to change other
  58.    cases to error 14.  If you ever find otherwise, please let me
  59.    know.
  60.                                                              14-2
  61.  
  62. ERROR 04: Bad Character In Number
  63.  
  64.    All numbers, and only numbers, start with a decimal digit.
  65.    (It's illegal to have a symbol begin with a digit; e.g.
  66.    01MYVAR .)   You have coded something that starts with a
  67.    decimal digit but does not have the correct format for a
  68.    numeric constant.  See Chapter 8 for detailed descriptions of
  69.    the formats of both integer and floating constants.
  70.  
  71. ERROR 05: Operands Not Allowed
  72.  
  73.    When this error is reported it usually means that you have
  74.    provided something more than just the mnemonic for an
  75.    instruction that does not have any operands: e.g., PUSHF,
  76.    STOSB, STC, FLDPI, CLTS.  It's also called in other contexts
  77.    when the assembler expects nothing more on the line; e.g.,
  78.    NAME with more than just a single name following, or something
  79.    following the word ENDS.
  80.  
  81. ERROR 06: Symbol Required
  82.  
  83.    This is reported in numerous situations where A86 requires
  84.    some sort of symbol: either a built-in assembler mnemonic, or
  85.    a symbol you define.  (It's possible that a number or some
  86.    punctuation marks are legal in the context, and that they have
  87.    already been checked for.)  Instead of a symbol, a punctuation
  88.    mark or out-of-context number was seen.  The contexts in which
  89.    this error can occur include:
  90.  
  91.     * the start of a line (characters hex 3C or greater)
  92.  
  93.     * after the following at the start of a line: a symbol you
  94.        define, #, #IF, IF, CODE, or DATA
  95.  
  96.     * where operands to the following directives are expected:
  97.        NAME, PUBLIC, EXTRN, GROUP, SEGMENT
  98.  
  99.     * after ">" denoting a local-label forward reference
  100.  
  101. ERROR 07: Local Symbol Required
  102.  
  103.    This is reported when something other than a generic local
  104.    label (letter followed by one or more digits) follows a ">"
  105.    mark, which denotes a local-label forward reference.  If you
  106.    meant "greater than" you use the GT operator instead.
  107.  
  108. ERROR 08: Too Many Operands
  109.  
  110.    This is reported for instructions and directives requiring a
  111.    limited number of operands, for which the limit is exceeded.
  112.    Since operands are separated by commas, you have too many
  113.    commas-- possibly an extra comma between the mnemonic and
  114.    first operand, or at the end of the operands.
  115.  
  116. ERROR 09: Constant Required
  117.                                                              14-3
  118.  
  119.    This is reported for instructions and directives (ENTER, RET,
  120.    RADIX, etc.) requiring operands that are an immediate constant
  121.    number; and for expression operators (*, /, SHL, OR, NOT, BY,
  122.    etc.) whose operands must be constant.  In some cases a
  123.    limited number of forms other than constants are acceptable,
  124.    but the assembler has already checked for and not found those
  125.    possibilities.
  126.  
  127. ERROR 10: More Operands Required
  128.  
  129.    This is reported for instructions requiring two operands, for
  130.    which you have provided no operands or only one operand.  You
  131.    might have left out the comma separating the operands.
  132.  
  133. ERROR 11: Constant/Label Not Allowed
  134.  
  135.    This is reported when you have given a constant number in a
  136.    place where it isn't allowed-- usually as a destination
  137.    operand to an instruction, such as the first operand to a MOV
  138.    or ADD.  If you meant the operand to be the memory location
  139.    with the constant offset, you must convert the type by
  140.    enclosing the operand in brackets [ ] or appending a
  141.    size-specifier (B, W, D, Q, or T) to the number.
  142.  
  143. ERROR 12: Segment Register Not Allowed
  144.  
  145.    This is reported when you have used a segment register in an
  146.    instruction where it isn't allowed.  The only instructions
  147.    allowing segment registers as operands are MOV, PUSH, and POP.
  148.    You can't, for example, ADD into a segment register.  If you
  149.    want to do anything with a segment register value, you have to
  150.    MOV it into a general register, perform the operation, then
  151.    MOV the result back to the segment register.
  152.  
  153. ERROR 13: Byte/Word Combination Not Allowed
  154.  
  155.    This is reported in a two-byte instruction in which one
  156.    operand is byte-sized and the other word-sized; or in an
  157.    instruction with a byte-sized destination and an immediate
  158.    source whose value is not byte-sized (high byte not 0 or 0FF).
  159.    If one of the operands is a memory variable of the wrong size,
  160.    you either change the declaration of the variable (DB to DW or
  161.    vice versa) or override the size of the variable in this
  162.    instruction only, by appending a " B" or " W" to the memory
  163.    operand.
  164.  
  165. ERROR 14: Bad Operand Combination
  166.  
  167.    This is reported when you attempt to add or combine terms in
  168.    an operand expression that do not allow combination.  An
  169.    example of this would be DT 3.7+BX.  Only constants can be
  170.    added to floating point numbers.
  171.  
  172.    This is also reported when you have two operands that are
  173.    mismatched in size, and the mismatch is something other than
  174.    Byte vs. Word. Example: MOV AL,D[0100].
  175.                                                              14-4
  176.  
  177. ERROR 15: Bad Subtraction Operands
  178.  
  179.    This is reported when you attempt to subtract terms in an
  180.    operand expression that do not allow subtraction, or if the
  181.    right-hand side to a subtraction is missing.  If the
  182.    right-hand side to a subtraction is a non-forward-referenced
  183.    constant, then the left side can be almost anything.
  184.    Otherwise, the operands must match; e.g., labels from
  185.    relocatable segments must be in the sam